Userland CO-PAGER: boosting data-intensive applications with non-volatile memory, userspace paging

With the emergence of low-latency non-volatile memory (NVM) storage, the software overhead, incurred by the operating system, becomes more prominent. The Linux (monolithic) kernel, incorporates a complex I/O subsystem design, using redundant memory copies and expensive user/kernel context switches to perform I/O. Memory-mapped I/O, which internally uses demand paging, has recently become popular when paired with low-latency storage. It improves I/O performance by mapping the data DMA transfers directly to userspace memory and removing the additional data copy between user/kernel space. However, for data-intensive applications, when there is insufficient physical memory, frequent page faults can still trigger expensive mode switches and I/O operations. To tackle this problem, we propose CO-PAGER, which is a lightweight userspace memory service. CO-PAGER consists of a minimal kernel module and a userspace component. The userspace component handles (redirected) page faults, performs memory management and I/O operations and accesses NVM storage directly. The kernel module is used to update memory mapping between user and kernel space. In this way CO-PAGER can bypass the deep kernel I/O stacks and provide a flexible/customizable and efficient memory paging service in userspace. We provide a general programming interface to use the CO-PAGER service. In our experiments, we also demonstrate how the CO-PAGER approach can be applied to a MapReduce framework and improves performance for data-intensive applications

Adaptive Prefetching for Device-Independent File I/O

Device independent I/O has been a holy grail to operating system designers since the early days of UNIX. Unfortunately, existing operating systems fall short of this goal for multimedia applications. Techniques such as caching and sequential read-ahead can help mask I/O latency in some cases, but in others they increase latency and add substantial jitter. Multimedia applications, such as video players, are sensitive to vagaries in performance since I/O latency and jitter affect the quality of presentation. Our solution uses adaptive prefetching to reduce both latency and jitter. Applications submit file access plans to the prefetcher, which then generates I/O requests to the operating system and manages the buffer cache to isolate the application from variations in device performance. Our experiments show device independence can be achieved: an MPEG video player sees the same latency when reading from a local disk or an NFS server. Moreover, our approach reduces jitter substantially

Fine-grain Period Adaptation in Soft Real-Time Environments

Reservation-based scheduling delivers a proportion of the CPU to jobs over a period of time. In this paper we argue that automatically determining and assigning this period is both possible and useful in general purpose soft real-time environments such as personal computers and information appliances. The goal of period adaptation is to select the period over which a job is guaranteed to receive its portion of the CPU dynamically and automatically. The choice of period represents a trade-off between the amount of jitter observed by the job and the overall efficiency of the system. Secondary effects of period include quantization error, job priority, changes in memory behavior, and battery life of portable devices. In addition to discussing these issues in detail, we present the design and evaluation of a mechanism for period adaptation based on feedback control. Together with an existing proportion allocation mechanism, this period adapter merges the benefits of best-effort and reservation-based systems by providing the fine-grain control of reservation-based scheduling without requiring applications to specify their own resource needs in advance

Adaptation Space: Surviving Non-Maskable Failures

Some failures cannot be masked by redundancies, because an unanticipated situation occurred, because fault-tolerance measures were not adequate, or because there was a security breach (which is not amenable to replication). Applications that wish to continue to offer some service despite nonmaskable failure must adapt to the loss of resources. When numerous combinations of non-maskable failure modes are considered, the set of possible adaptations becomes complex. This paper presents adaptation spaces, a formalism for navigating among combinations of adaptations. An adaptation space describes a collection of possible adaptations of a software component or system, and provides a uniform way of viewing a group of alternative software adaptations. Adaptation spaces describe the different means for monitoring the conditions that different adaptations depend on, and the particular configurations through which an adaptive application navigate. Our goal is to use adaptation spaces to provide survivable services to applications despite non-maskable failures such as malicious attacks. We present the basic concepts concerning adaptation spaces, with examples. We then present a formal model for reasoning about and selecting alternative adaptations, allowing developers of survivable application to automate their system’s adaptive behavior

Virtual memory alternatives for transaction buffer management in a single-level store

Thesis (Ph. D.)--University of Washington, 1996This dissertation addresses a key issue in the efficient execution of transaction systems in shared environments. Until recently, transaction systems typically ran on dedicated database server machines. Transaction systems are increasingly popular beyond the database domain, and thus are often run outside of the dedicated server environment: on client machines, personal computers on user desktops, or multi-use enterprise servers. The key difference between these environments is that server machines are dedicated to running one application (e.g., a database server) in isolation, while in the other environments the machine is shared by multiple applications (e.g., word processors, email programs, web browsers, and applications that use transactions). In these latter environments, the transaction system needs to cooperate with the operating system to effectively share the resources of the machine with all of the applications on the machine.In this dissertation, we first describe a space of trade-offs between transaction performance in a multiprogrammed environment and the required degree of customized operating system support. We argue that the current alternatives represent the two possible extremes: poor performance with no additional support required, and excellent performance with extensive operating system support required.Second, we present a new point in the space of trade-offs that is between these extremes. This technique improves performance over current practice by utilizing existing operating system facilities to integrate transaction buffer management with operating system virtual memory management.Third, we describe an implementation of the new approach in a commercial operating system, Digital Unix, running on AlphaStation 250 workstations. We also present two more systems, built on the same platform, that are representative of the two existing alternatives. The implementation of the three systems on an identical platform enables, for the first time, a fair evaluation of the full spectrum of degrees of virtual memory support for transaction buffer management.We conclude that current transaction buffer management designs perform poorly in the increasingly common memory-competitive environments. We argue that this poor performance is the result of fundamental structural decisions. We lend evidence to this argument by demonstrating significant performance improvements in a restructured transaction buffer management system that uses existing operating systems facilities. Finally, we demonstrate prototype implementations of transaction support that will be available in future extensible operating systems that provide further performance improvements

Improving the Performance of Message-Passing Applications by Multithreading

Achieving maximum performance in message-passing programs requires that calculation and communication be overlapped. However, the program transformations required to achieve this overlap are error-prone and add significant complexity to the application program. We argue that calculation/communication overlap can be achieved easily and consistently by executing multiple threads of control on each processor, and that this approach is practical on message-passing architectures without any special hardware support. We present timing data for a typical message-passing application, to demonstrate the advantages of our scheme. 1 Introduction The most natural way to program many scientific algorithms on message-passing machines is in the loosely synchronous, or coarse-grain data parallel, style. Such programs alternate between phases of pure calculation and pure communication. This approach is easy for the programmer to understand, so the resulting programs are relatively simple to debug and ..

Extending The Mach External Pager Interface To Accommodate User-Level Page Replacement Policies

The Mach external pager interface allows applications to supply their own routines for moving pages to and from second-level store. Mach doesn't allow applications to choose their own page replacement policy, however. Some applications have access patterns that may make least recently used page replacement inappropriate. In this paper, we describe an extension to the external pager interface that allows the programmer to specify the page replacement policy as well as the backing storage for a region of virtual memory. 1 Introduction An operating system attempts to be all things to all users. Because of this, sometimes compromises have to be made; performance may be sacrificed for generality, or modularity for performance. Virtual memory page replacement schemes are an example of such a tradeoff. While the LRU page replacement policy rarely misbehaves grossly, it rarely provides optimal performance for any application. For some groups of applications we may suspect that a different pag..

Predictable File Access Latency for Multimedia

Multimedia applications are sensitive to I/O latency and jitter when accessing data in secondary storage. Transparent adaptive prefetching (TAP) uses software feedback to provide multimedia applications with file system quality of service (QoS) guarantees. We are investigating how QoS requirements can be communicated and how they can be met by adaptive resource management. A preliminary test of adaptive prefetching is presented

Dynamic Load Distribution in MIST

This paper presents an algorithm for scheduling parallel applications in large-scale, multiuser, heterogeneous distributed systems. The approach is primarily targeted at systems that harvest idle cycles in general-purpose workstation networks, but is also applicable to clustered computer systems and massively parallel processors. The algorithm handles unequal processor capacities, multiple architecture types and dynamic variations in the number of processes and available processors. Scheduling decisions are driven by the desire to minimize turnaround time while maintaining fairness among competing applications. For efficiency, the virtual processors (VPs) of each application are gang scheduled on some subset of the available physical processors